package com.neusoft.ch1.opt;
/*
 * 课堂笔记：
 * 运算符
 *    0、运算符根据使用的操作数的个数分为：一元运算符、二元运算符、三元运算符
 *       加法 + 是两元运算符：  i+j  有两个操作数 i、j； 2+3 
 *       负号 - 是一元运算符： -1， -2
 *    1、算数运算符       
 *       + - * / % 是两元运算符
 *       ++ --  是一元运算符
 *       
 *       ++：自增运算。变量在当前值的基础之上进行+1运算。
 *       --：自减运算。变量在当前值的基础之上进行-1运算。
 *       
 *       解析：
 *           自增（自减）运算运算中包含两种值：★★★★★
 *              一种：变量自身的值；
 *              一种：自增自减表达式的值；   
 *           例如：先自增表达式 ++iVal21 中，包含变量iVal21自身的值；还有表达式 ++iVal21 的值；
 *           
 *           先自增和后自增的区别：★★★★★
 *           
 *                         先自增                                                               后自增             
 *           变量：                  变量自身的初始值+1             变量自身的初始值+1
 *           表达式：              变量初始值+1                   变量的初始值
 *           
 *           总结：★★★★★
 *               无论是先自增还是后自增变量自身的值都是+1
 *               先自增表达式的值是变量的原始值+1；
 *               后自增表达式的值是变量的原始值；
 *           
 *           自减运算同理。
 *           
 *       注意：
 *          除数不能为0
 *          整数数据除法为整数，会舍弃掉小数点后面的数
 *          %运算余数作为结果
 *          算数运算中可以使用()改变运算的优先级；
 *          运算顺序默认从左向右；
 *          先乘除后加减；（运算符之间有优先级）
 *          
 *    2、赋值运算
 *         将一个常数或者表达式的值赋值给一个变量；
 *         给变量进行赋值操作；
 *         都是两元运算符；
 *         赋值运算符：=、+=、﹣=、*=、/=、%=
 *         +=运算符：
 *         i+=3;等价于 i=i+3;
 *         i+=j;等价于 i=i+j;
 *               
 *    3、比较运算
 *       比较运算符：>、<、>=、 <=、==、!=、instanceof(暂时不讲，后面再讲)  
 *       都是两元运算符
 *       注意：
 *           比较运算的结果是boolean类型(比较运算的结果只有true或false)；
 *    
 *    4、 逻辑运算符
 *       非 ! 是一元运算符
 *       与&&、或|| 是两元运算符
 *       逻辑运算的操作数都是boolean类型；逻辑运算的结果还是boolean类型；
 *       操作数可以变量也可以是表达式，但是要求变量的值和表达式的结果都是boolean类型
 *       语法：
 *           非!运算:
 *             !true = false
 *             !false = true
 *              非运算的操作数可以是变量也可以是表达式；  
 *           
 *           与&&运算：
 *           T&&T = T
 *           T&&F = F
 *           F&&T = F
 *           F&&F = F
 *              只有两个操作数同时为T是结果才是T；只要有一个操作数为F结果就为F
 *           
 *           或||运算：
 *           T||T = T
 *           T||F = T
 *           F||T = T
 *           F||F = F
 *              只有两个操作数同时为F是结果才是F；只要有一个操作数为T结果就为T   
 *      逻辑短路：
 *         与短路：
 *            当有多个连续的与运算时，从左往右开始如果出现一个操作数的结果为false，则，
 *            整个与运算终止,整个表达式结果为false，其后的表达式将不会再被执行；
 *         或短路：
 *            当有多个连续的或运算时，从左往右开始如果出现一个操作数的结果为true，则，
 *            整个或运算终止,整个表达式结果为true，其后的表达式将不会再被执行；
 *            
 *         混合短路（不作要求）：根据表达式运算级别的层次关系，逐层进行判定。    
 *   
 *    5、位运算符
 *       位运算时对计算机中存储的二进制的位进行运算的操作符。
 *       操作数是二进制的0或1；
 *       计算机中所有的数都是以补码存在的，位运算也是在补码的基础之上进行的，位运算的结果也是补码；★★★★★
 *       按位 与&、或|、异或^ 、取反 ~、右移>>、左移<<、带符号的右移>>>      
 *       语法：
 *          与& 两元运算符
 *          1&1 = 1
 *          1&0 = 0
 *          0&1 = 0
 *          0&0 = 0
 *          
 *          或| 两元运算符
 *          1|1 = 1
 *          1|0 = 1
 *          0|1 = 1
 *          0|0 = 0
 *          
 *          异或^ 两元运算符
 *          1^1 = 0
 *          1^0 = 1
 *          0^1 = 1
 *          0^0 = 0
 *          
 *          总结：两个操作数相同为0；不同为1；    
 *          
 *          取反~ 一元运算符
 *          ~1 = 0
 *          ~0 = 1
 *           
 *           
 */
public class TestOpt {

	public static void main(String[] args) {
		// 算数运算符 除法
		int iVal11 = 10;
		// int iVal12 = 0; // 除数不能为0
		int iVal12 = 3;
		int iVal13 = iVal11 / iVal12;
		System.out.println("除法运算结果为：" + iVal13);

		// 求余运算
		int iVal14 = iVal11 % iVal12;
		System.out.println("求余运算结果为：" + iVal14);

		////////////////////////////////////////////
		System.out.println("================================");
		// 初始变量为3
		int iVal21 = 3;
		System.out.println("先自增运算：");
		System.out.println("运算前变量iVal21的值为："+iVal21);
		// 进行先自增运算
		int iVal22 = ++iVal21;
		System.out.println("先自增运算后变量iVal21结果为：" + iVal21);
		System.out.println("表达式++iVal21结果为：" + iVal22);
		
		System.out.println("================================");
		// 重新初始变量为3
		iVal21 = 3;
		System.out.println("后自增运算：");
		System.out.println("运算前变量iVal21的值为："+iVal21);
		// 进行后自增运算
		int iVal23 = iVal21++;
		System.out.println("后自增运算后变量iVal21结果为：" + iVal21);
		System.out.println("表达式iVal21++结果为：" + iVal23);
		
		System.out.println("================================");
		int iVal30 = 4;
		System.out.println("iVal30=" + iVal30);
		System.out.println("++iVal30=" + (++iVal30)); // 变量iVal30=5  表达式++iVal30=5
		System.out.println("iVal30++=" + iVal30++); // 变量iVal30=6  表达式iVal30++=5
		
		System.out.println("================================");
		// 赋值运算
		int iVal40 = 5;
		// +=赋值运算
		iVal40 += 5;
		// 等价于
		// iVal40 = iVal40+5;
		System.out.println("iVal40=" + iVal40);

		byte bVal10 = 5;
		bVal10 += 5; // 5 表示计算的一个偏移量
		bVal10 = (byte) (bVal10 + 5);
		System.out.println("bVal10=" + bVal10);

		System.out.println("================================");
		int iVal50 = 5, iVal51 = 6;
		// 比较运算
		boolean isMax = iVal50 < iVal51;
		System.out.println("比较结果：" + isMax);
		
		System.out.println("================================");
		// 变量
		int iVal61 = 10;
		int iVal62 = 11;
		int iVal63 = 12;
		// 逻辑运算(出现逻辑与短路)
		boolean isOK = iVal61++ > iVal62 && --iVal63 == iVal62;// iVal61=11  iVal63=11
		System.out.println("isOK=" + isOK); // false
		System.out.println("iVal61="+iVal61);
		System.out.println("iVal63="+iVal63);
		
		// 或短路
		// 重新初始化变量的值
		iVal61 = 10;
		iVal62 = 11;
		iVal63 = 12;
		// 逻辑运算(出现逻辑与短路)
		// 没有出现短路
		boolean isOK2 = iVal61++ > iVal62 || --iVal63 == iVal62;// iVal61=11 iVal63=11
		System.out.println("isOK2=" + isOK2); // true
		System.out.println("iVal61=" + iVal61); // 11
		System.out.println("iVal63=" + iVal63); // 11
		
		// 或短路
		// 重新初始化变量的值
		iVal61 = 10;
		iVal62 = 11;
		iVal63 = 12;
		// 逻辑运算(出现逻辑与短路)
		// 没有出现短路
		boolean isOK3 = ++iVal61 >= iVal62 || --iVal63 == iVal62;// iVal61=11 iVal63=12
		System.out.println("isOK3=" + isOK3); // true
		System.out.println("iVal61=" + iVal61); // 11
		System.out.println("iVal63=" + iVal63); // 12
		
		//////////////////////////////////////////
		System.out.println("=============位运算===============");
		// 位运算
		int iVal71 = 3; // 0000 0011（补码） 
		int iVal72 = 4; // 0000 0100（补码）
		// 位与
		int iVal73 = iVal71 & iVal72;// 0000 0000      
		System.out.println("3&4=" + iVal73);
		// 位或
		int iVal74 = iVal71 | iVal72;// 0000 0111
		System.out.println("3|4=" + iVal74);
		// 位异或
		int iVal75 = iVal71 ^ iVal72;// 0000 0111
		System.out.println("3^4=" + iVal75);
		
		// 位取反
		int iVal76 = ~iVal71;// 1111 1100（补码）
		System.out.println("~3=" + iVal76);
	}

}
